    // 触发更新视图
    function updateView() {
        console.log('视图更新')
    }
    // 重新定义属性，监听起来（核心）
    function defineReactive(target, key, value) {
        // 深度监听
        observer(value)
        // 核心 API
        Object.defineProperty(target, key, {
            get() {
                return value
            },
            set(newValue) {
                if (newValue != value) {
                // 深度监听
                observer(newValue)
                // 设置新值
                // 注意，value 一直在闭包中，此处设置完之后，再 get 时也是会获取最新的值
                value = newValue
        
                // 触发视图更新
                updateView()
                }
            }
        })
    }
    // 深度监听
    function observer(target) {
        if (typeof target !== 'object' || target === null) {
            // 不是对象或数组
            return target
        }
        // 重新定义各个属性（for in 也可以遍历数组）
        for (let key in target) {
            defineReactive(target, key, target[key])
        }
    }
    // 准备数据
    const data = {
        name: '大伟聊前端',
        obj: {}
    }
    
    // 开始监听
    observer(data)
    
    // 测试1
    data.name = {
        lastName: '大伟聊前端2',
        obj: {
            a: {b:{c:{}}}
        }
    }
    
    // 测试2
    data.name.lastName = '大伟聊前端3'
    
    // 以上就是 深度监听 的原理，其实就是递归。
    
    // 但递归有个不好的地方，就是如果对象层次很深，需要计算的量就很大，因为需要一次计算到底